package com.myzk.example.utils.common;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串工具类
 *
 * @author mayong
 * @date 2020年11月4日
 */
public class StringUtil {
    /**
     * 判断字符串是否为空
     *
     * @param str
     * @return
     */
    public static boolean isEmpty(String str) {
        return str == null || str.length() == 0;
    }

    /**
     * 判断字符串是否非空
     *
     * @param str
     * @return
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 判断字符串内容是否为空
     *
     * @param str
     * @return
     */
    public static boolean isBlank(String str) {
        int strLen;
        if (str == null || (strLen = str.length()) == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断字符串内容是否为非空
     *
     * @param str
     * @return
     */
    public static boolean isNotBlank(String str) {
        return !isNotBlank(str);
    }

    /**
     * 获取字符串的UTF-8格式字节码
     *
     * @param str
     * @return
     */
    public static byte[] getBytesUtf8(String str) {
        return str.getBytes(StandardCharsets.UTF_8);
    }

    /**
     * 获取字符串指定编码格式字节码
     *
     * @param str
     * @param charsetName
     * @return
     */
    public static byte[] getBytesUnchecked(String str, String charsetName) {
        if (str == null) {
            return null;
        }
        try {
            return str.getBytes(charsetName);
        } catch (UnsupportedEncodingException e) {
            //e.printStackTrace();
            return new byte[0];
        }
    }

    /**
     * 以UTF-8编码格式创建字符串
     *
     * @param bytes
     * @return
     */
    public static String newStringUtf8(byte[] bytes) {
        return new String(bytes, StandardCharsets.UTF_8);
    }

    public static String newString(byte[] bytes, Charset charset) {
        return bytes == null ? null : new String(bytes, charset);
    }

    public static String newString(byte[] bytes, String charsetName) {
        if (bytes == null) {
            return null;
        }
        try {
            return new String(bytes, charsetName);
        } catch (UnsupportedEncodingException ex) {
            return null;
        }
    }

    /**
     * 判断两个字符串是否相等
     *
     * @param str1
     * @param str2
     * @return
     */
    public static boolean equal(String str1, String str2) {
        if (str1 == str2) {
            return true;
        }
        if (str1 == null || str2 == null) {
            return false;
        }
        return str1.equals(str2);
    }

    /***
     * 字符串截取（支持负数下标，负数表示从后面倒数第几个位置开始）
     * @param str
     * @param beginIndex 开始位置
     * @param endIndex  结束位置
     * @return
     */
    public static String substring(String str, int beginIndex, int endIndex) {
        if (str == null) {
            return null;
        }
        int strLen = str.length();
        if (beginIndex < 0) {
            beginIndex = Math.max(strLen + beginIndex, 0);
        }
        if (endIndex <= 0) {
            endIndex = strLen + endIndex;
        }
        return beginIndex < endIndex ? str.substring(beginIndex, endIndex) : "";
    }


    /**
     * 字符串截取（从指定位置截取到最后）
     *
     * @param str
     * @param beginIndex 开始位置(支持负数，负数表示倒数位置）
     * @return
     */
    public static String substring(String str, int beginIndex) {
        return substring(str, beginIndex, 0);
    }


    public static String unicodeEncode(String string) {
        char[] utfBytes = string.toCharArray();
        String unicodeBytes = "";
        for (int i = 0; i < utfBytes.length; i++) {
            String hexB = Integer.toHexString(utfBytes[i]);
            if (hexB.length() <= 2) {
                hexB = "00" + hexB;
            }
            unicodeBytes = unicodeBytes + "\\u" + hexB;
        }
        return unicodeBytes;
    }

    private static final  Pattern unicodePattern = Pattern.compile("(\\\\u(\\p{XDigit}{4}))");

    public static String unicodeDecode(String string) {
        Matcher matcher = unicodePattern.matcher(string);
        char ch;
        while (matcher.find()) {
            ch = (char) Integer.parseInt(matcher.group(2), 16);
            string = string.replace(matcher.group(1), ch + "");
        }
        return string;
    }
}
